{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "04a72c0e",
   "metadata": {},
   "source": [
    "# The Continuous Thought Machine – Tutorial 04: Parity [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/SakanaAI/continuous-thought-machines/blob/main/examples/04_parity.ipynb) [![arXiv](https://img.shields.io/badge/arXiv-2505.05522-b31b1b.svg)](https://arxiv.org/abs/2505.05522)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b05cf27b",
   "metadata": {},
   "source": [
    "### Parity\n",
    "\n",
    "The parity of a binary sequence, given by the sign of the product of its elements, can reasonably be predicted by an RNN when the data is fed sequentially - the model need only maintain an internal state, flipping a ‘switch’ whenever a negative number is encountered. When the entire sequence is provided at once, however, the task is significantly more challenging.\n",
    "\n",
    "In Section 8 of the [technical report](https://arxiv.org/pdf/2505.05522), we showcase how a CTM can be trained to do exactly this. In particular, we input the CTM with a binary sequence, and train the model to predict the cumulative parity at each position along the sequence."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dbffa93",
   "metadata": {},
   "source": [
    "### Tutorial Overview"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07c2bbea",
   "metadata": {},
   "source": [
    "In this tutorial, we walk through how we trained the CTM, using sequences of length 16."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2272f18",
   "metadata": {},
   "source": [
    "### Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c257dbd3",
   "metadata": {},
   "source": [
    "In addition to installing some dependencies, we also clone the CTM repo (assuming this tutorial is being run in Colab), so that we can access the base CTM model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c06d1e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "USE_COLAB = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30ab5f0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "if USE_COLAB:\n",
    "    !git clone https://github.com/SakanaAI/continuous-thought-machines.git\n",
    "    sys.path.append(\"./continuous-thought-machines\")\n",
    "else:\n",
    "    sys.path.append(\"..\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1ccfdcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install gdown\n",
    "!pip install mediapy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ab57a96",
   "metadata": {},
   "source": [
    "Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24ffe416",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import random\n",
    "from torch.utils.data import Dataset\n",
    "from tqdm.auto import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display, clear_output\n",
    "import imageio\n",
    "import mediapy\n",
    "\n",
    "# From CTM repo\n",
    "from models.ctm import ContinuousThoughtMachine as CTM\n",
    "from tasks.parity.plotting import make_parity_gif\n",
    "from tasks.parity.utils import reshape_attention_weights, reshape_inputs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82620e4e",
   "metadata": {},
   "source": [
    "Set a seed for reproducibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "604415b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_seed(seed=42, deterministic=True):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    torch.backends.cudnn.deterministic = deterministic\n",
    "    torch.backends.cudnn.benchmark = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b2ba7f7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "set_seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4407a4a8",
   "metadata": {},
   "source": [
    "### Data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e271bc4c",
   "metadata": {},
   "source": [
    "We define a dataset to create the parity sequences for training and testing. Each sample is a sequence of length `sequence_length`, where we randomly place -1s and 1s at each position. We calculate the target sequence (of the same length) as the parity upto and including that position, with 0s corresponding to negative parity and 1s corrsponding to positive parity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "830313fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ParityDataset(Dataset):\n",
    "    def __init__(self, sequence_length=64, length=100000):\n",
    "        self.sequence_length = sequence_length\n",
    "        self.length = length\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.length\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        vector = 2 * torch.randint(0, 2, (self.sequence_length,)) - 1\n",
    "        vector = vector.float()\n",
    "        negatives = (vector == -1).to(torch.long)\n",
    "        cumsum = torch.cumsum(negatives, dim=0)\n",
    "        target = (cumsum % 2 != 0).to(torch.long)\n",
    "        return vector, target"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39ec4d00",
   "metadata": {},
   "source": [
    "We set the parity sequence length to `grid_size ** 2 = 16`, and prepare the train and test loaders. We use a `batch_size` of 64."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cc28def0",
   "metadata": {},
   "outputs": [],
   "source": [
    "grid_size = 4\n",
    "parity_sequence_length = grid_size ** 2\n",
    "\n",
    "train_data = ParityDataset(sequence_length=parity_sequence_length, length=100000)\n",
    "test_data = ParityDataset(sequence_length=parity_sequence_length, length=10000)\n",
    "\n",
    "trainloader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True, num_workers=0)\n",
    "testloader = torch.utils.data.DataLoader(test_data, batch_size=64, shuffle=True, num_workers=0, drop_last=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e94a149b",
   "metadata": {},
   "source": [
    "We can visualise what these inputs and targets look like. White squares correspond to positive parity, and black squares correspond to negative parity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "33503097",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: [-1.0, -1.0, 1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, -1.0, 1.0, -1.0]\n",
      "Target: [1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "sample_inputs, sample_targets = next(iter(trainloader))\n",
    "sample_input = sample_inputs[0,:].reshape(grid_size, grid_size)\n",
    "sample_target = sample_targets[0,:].reshape(grid_size, grid_size)\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(6, 3))\n",
    "\n",
    "# Plot the input\n",
    "ax1.imshow(sample_input.flip(0), cmap='gray')\n",
    "for i in range(grid_size+1):\n",
    "    ax1.axhline(i-0.5, color='black', linewidth=2,)\n",
    "    ax1.axvline(i-0.5, color='black', linewidth=2)\n",
    "ax1.set_xlim(-0.5, grid_size-0.5)\n",
    "ax1.set_ylim(-0.5, grid_size-0.5)\n",
    "ax1.set_xticks([])\n",
    "ax1.set_yticks([])\n",
    "ax1.set_title('Input')\n",
    "\n",
    "# Plot the target\n",
    "ax2.imshow(sample_target.flip(0), cmap='gray')\n",
    "for i in range(grid_size+1):\n",
    "    ax2.axhline(i-0.5, color='black', linewidth=2)\n",
    "    ax2.axvline(i-0.5, color='black', linewidth=2)\n",
    "ax2.set_xlim(-0.5, grid_size-0.5)\n",
    "ax2.set_ylim(-0.5, grid_size-0.5)\n",
    "ax2.set_xticks([])\n",
    "ax2.set_yticks([])\n",
    "ax2.set_title('Target')\n",
    "\n",
    "plt.tight_layout()\n",
    "print(f\"Input: {sample_inputs[0].tolist()}\")\n",
    "print(f\"Target: {sample_targets[0].tolist()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "069121b9",
   "metadata": {},
   "source": [
    "### Loss Function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88d91d78",
   "metadata": {},
   "source": [
    "Next we define the loss function. First, for all internal ticks of the CTM, we calculate the cross-entropy loss for all positions along the output sequence. Then, as with the other experiments, we only use the loss at two specific internal ticks: where the loss is the lowest and where the model is most certain. We use advanced indexing into the losses tensor to extract these losses, and then average them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63e75f71",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parity_loss(predictions, certainties, targets, use_most_certain=True):\n",
    "    \"\"\"\n",
    "    Computes the parity loss.\n",
    "\n",
    "    Predictions are of shape: (B, parity_sequence_length, class, internal_ticks),\n",
    "        where classes are in [0,1,2,3,4] for [Up, Down, Left, Right, Wait]\n",
    "    Certainties are of shape: (B, 2, internal_ticks), \n",
    "        where the inside dimension (2) is [normalised_entropy, 1-normalised_entropy]\n",
    "    Targets are of shape: [B, parity_sequence_length]\n",
    "\n",
    "    use_most_certain will select either the most certain point or the final point. For baselines,\n",
    "        the final point proved the only usable option. \n",
    "    \"\"\"\n",
    "\n",
    "    # Losses are of shape [B, parity_sequence_length, internal_ticks]\n",
    "    losses = nn.CrossEntropyLoss(reduction='none')(predictions.flatten(0,1), torch.repeat_interleave(targets.unsqueeze(-1), predictions.size(-1), -1).flatten(0,1).long()).reshape(predictions[:,:,0].shape)\n",
    "\n",
    "    # Average the loss over the parity sequence dimension\n",
    "    losses = losses.mean(1)\n",
    "\n",
    "    loss_index_1 = losses.argmin(dim=1)\n",
    "    loss_index_2 = certainties[:,1].argmax(-1)\n",
    "    if not use_most_certain:\n",
    "        loss_index_2[:] = -1\n",
    "    \n",
    "    batch_indexer = torch.arange(predictions.size(0), device=predictions.device)\n",
    "    loss_minimum_ce = losses[batch_indexer, loss_index_1].mean()\n",
    "    loss_selected = losses[batch_indexer, loss_index_2].mean()\n",
    "\n",
    "    loss = (loss_minimum_ce + loss_selected)/2\n",
    "    return loss, loss_index_2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a712a9a9",
   "metadata": {},
   "source": [
    "### Training"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89cb8dd7",
   "metadata": {},
   "source": [
    "We define some helper functions for making the progress bar look pretty, and to display the training curves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fb57caee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_pbar_desc(train_loss, train_accuracy, test_loss, test_accuracy, lr, where_most_certain):\n",
    "    \"\"\"A helper function to create a description for the tqdm progress bar\"\"\"\n",
    "    pbar_desc = f'Train Loss={train_loss:0.3f}. Train Acc={train_accuracy:0.3f}. Test Loss={test_loss:0.3f}. Test Acc={test_accuracy:0.3f}. LR={lr:0.6f}.'\n",
    "    pbar_desc += f' Where_certain={where_most_certain.float().mean().item():0.2f}+-{where_most_certain.float().std().item():0.2f} ({where_most_certain.min().item():d}<->{where_most_certain.max().item():d}).'\n",
    "    return pbar_desc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "19208f41",
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_training_curve_plot(fig, ax1, ax2, train_losses, test_losses, train_accuracies, test_accuracies, steps):\n",
    "    clear_output(wait=True)\n",
    "    \n",
    "    # Plot loss\n",
    "    ax1.clear()\n",
    "    ax1.plot(range(len(train_losses)), train_losses, 'b-', alpha=0.7, label=f'Train Loss: {train_losses[-1]:.3f}')\n",
    "    ax1.plot(steps, test_losses, 'r-', marker='o', label=f'Test Loss: {test_losses[-1]:.3f}')\n",
    "    ax1.set_title('Loss')\n",
    "    ax1.set_xlabel('Step')\n",
    "    ax1.set_ylabel('Loss')\n",
    "    ax1.legend()\n",
    "    ax1.grid(True, alpha=0.3)\n",
    "\n",
    "    # Plot accuracy\n",
    "    ax2.clear()\n",
    "    ax2.plot(range(len(train_accuracies)), train_accuracies, 'b-', alpha=0.7, label=f'Train Accuracy: {train_accuracies[-1]:.3f}')\n",
    "    ax2.plot(steps, test_accuracies, 'r-', marker='o', label=f'Test Accuracy: {test_accuracies[-1]:.3f}')\n",
    "    ax2.set_title('Accuracy')\n",
    "    ax2.set_xlabel('Step')\n",
    "    ax2.set_ylabel('Accuracy')\n",
    "    ax2.legend()\n",
    "    ax2.grid(True, alpha=0.3)\n",
    "\n",
    "    plt.tight_layout()\n",
    "    display(fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71541842",
   "metadata": {},
   "source": [
    "We then write the function to train the CTM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "02de7c62",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, trainloader, testloader, device='cpu', training_iterations=10000, test_every=1000, lr=1e-4, log_dir='./logs'):\n",
    "\n",
    "    os.makedirs(log_dir, exist_ok=True)\n",
    "    \n",
    "    model.train()\n",
    "    optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n",
    "    iterator = iter(trainloader)\n",
    "    \n",
    "    train_losses = []\n",
    "    test_losses = []\n",
    "    train_accuracies = []\n",
    "    test_accuracies = []\n",
    "    steps = []\n",
    "    \n",
    "    plt.ion()\n",
    "    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))\n",
    "\n",
    "    with tqdm(total=training_iterations) as pbar:\n",
    "        for stepi in range(training_iterations):\n",
    "\n",
    "            try:\n",
    "                inputs, targets = next(iterator)\n",
    "            except StopIteration:\n",
    "                iterator = iter(trainloader)\n",
    "                inputs, targets = next(iterator)\n",
    "    \n",
    "            inputs, targets = inputs.to(device), targets.to(device)\n",
    "            \n",
    "            optimizer.zero_grad()\n",
    "            \n",
    "            predictions_raw, certainties, _ = model(inputs)\n",
    "\n",
    "            # Reshape: (B, SeqLength, C, T)\n",
    "            predictions = predictions_raw.reshape(predictions_raw.size(0), -1, 2, predictions_raw.size(-1))\n",
    "            \n",
    "            # Compute loss\n",
    "            train_loss, where_most_certain = parity_loss(predictions, certainties, targets, use_most_certain=True)\n",
    "            train_accuracy = (predictions.argmax(2)[torch.arange(predictions.size(0), device=predictions.device), :, where_most_certain] == targets).float().mean().item()\n",
    "\n",
    "            train_losses.append(train_loss.item())\n",
    "            train_accuracies.append(train_accuracy)\n",
    "\n",
    "            train_loss.backward()\n",
    "            optimizer.step()\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            if stepi % test_every == 0 or stepi == 0:\n",
    "                model.eval()\n",
    "                with torch.no_grad():\n",
    "                    all_test_predictions = []\n",
    "                    all_test_targets = []\n",
    "                    all_test_where_most_certain = []\n",
    "                    all_test_losses = []\n",
    "\n",
    "                    for inputs, targets in testloader:\n",
    "                        inputs = inputs.to(device)\n",
    "                        targets = targets.to(device)\n",
    "                        \n",
    "                        predictions_raw, certainties, where_most_certain = model(inputs)\n",
    "                        predictions = predictions_raw.reshape(predictions_raw.size(0), -1, 2, predictions_raw.size(-1))\n",
    "                        \n",
    "                        test_loss, where_most_certain = parity_loss(predictions, certainties, targets, use_most_certain=True)\n",
    "                        all_test_losses.append(test_loss.item())\n",
    "                        all_test_predictions.append(predictions)\n",
    "                        all_test_targets.append(targets)\n",
    "                        all_test_where_most_certain.append(where_most_certain)\n",
    "\n",
    "                    all_test_predictions = torch.cat(all_test_predictions, dim=0)\n",
    "                    all_test_targets = torch.cat(all_test_targets, dim=0)\n",
    "                    all_test_where_most_certain = torch.cat(all_test_where_most_certain, dim=0)\n",
    "\n",
    "                    test_accuracy = (all_test_predictions.argmax(2)[torch.arange(all_test_predictions.size(0), device=predictions.device), :, all_test_where_most_certain] == all_test_targets).float().mean().item()\n",
    "                    test_loss = sum(all_test_losses) / len(all_test_losses)\n",
    "\n",
    "                    test_losses.append(test_loss)\n",
    "                    test_accuracies.append(test_accuracy)\n",
    "                    steps.append(stepi)\n",
    "\n",
    "                    create_maze_gif_visualization(model, testloader, device, log_dir)\n",
    "\n",
    "                model.train()\n",
    "\n",
    "                update_training_curve_plot(fig, ax1, ax2, train_losses, test_losses, train_accuracies, test_accuracies, steps)\n",
    "\n",
    "            pbar_desc = make_pbar_desc(train_loss=train_loss.item(), train_accuracy=train_accuracy, test_loss=test_loss, test_accuracy=test_accuracy, lr=optimizer.param_groups[-1][\"lr\"], where_most_certain=where_most_certain)\n",
    "            pbar.set_description(pbar_desc)\n",
    "            pbar.update(1)\n",
    "\n",
    "    plt.ioff()\n",
    "    plt.close(fig)\n",
    "    return model\n",
    "\n",
    "def create_maze_gif_visualization(model, testloader, device, log_dir):\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        inputs_viz, targets_viz = next(iter(testloader))\n",
    "        inputs_viz = inputs_viz.to(device)\n",
    "        targets_viz = targets_viz.to(device)\n",
    "\n",
    "        predictions_raw, certainties, _, pre_activations, post_activations, attention = model(inputs_viz, track=True)\n",
    "        \n",
    "        # Reshape predictions\n",
    "        predictions = predictions_raw.reshape(predictions_raw.size(0), -1, 2, predictions_raw.size(-1))\n",
    "        \n",
    "        attention = reshape_attention_weights(attention)\n",
    "        inputs = reshape_inputs(inputs_viz, 50, grid_size=grid_size)\n",
    "\n",
    "        # Generate the parity GIF\n",
    "        make_parity_gif(\n",
    "            predictions.detach().cpu().numpy(),\n",
    "            certainties.detach().cpu().numpy(),\n",
    "            targets_viz.detach().cpu().numpy(),\n",
    "            pre_activations,\n",
    "            post_activations,\n",
    "            attention,\n",
    "            inputs,\n",
    "            f'{log_dir}/prediction.gif',\n",
    "        )\n",
    "        \n",
    "        predictions_raw, certainties, _ = model(inputs_viz)\n",
    "        predictions = predictions_raw.reshape(predictions_raw.size(0), -1, 2, predictions_raw.size(-1))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67e6c8fc",
   "metadata": {},
   "source": [
    "### Initialzing the CTM "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a9cac52",
   "metadata": {},
   "source": [
    "Next we initialize the CTM. There are three important arguments to highlight for this task, which differ from, for example, the image classification task.\n",
    "\n",
    "- `backbone_type = 'parity_backbone'`: the backbone type `'parity_backbone'`, which is defined in the CTM repo, is a learned embedding layer which embeds the binary values in the input sequence.\n",
    "- `positional_embedding_type = 'custom-rotational-1d'`: a positional embedding for each position in the parity sequence. These positional embeddings are added to the embedding vectors (produced by the backbone) during the forward pass.\n",
    "- `prediction_reshaper = [parity_sequence_length, 2]`: the CTM has an optional argument `prediction_reshaper`. This is required when the output of the model is a sequence. For instance, it is required here where the output is a sequence of parities, or in the maze task where the output is a sequence of actions. This prediction reshaper is used in each internal tick of the CTM when the certainty of the models output is computed. Generally, the prediction reshaper should be like `[SEQUENCE_LENGTH, NUM_CLASS]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2c180995",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using neuron select type: random-pairing\n",
      "Synch representation size action: 256\n",
      "Synch representation size out: 256\n",
      "Model parameters: 652,106\n"
     ]
    }
   ],
   "source": [
    "# Set device\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "\n",
    "# Define the model\n",
    "model = CTM(\n",
    "    iterations = 50,\n",
    "    d_model = 256,\n",
    "    d_input = 32,\n",
    "    heads = 8,\n",
    "    n_synch_out = 256,\n",
    "    n_synch_action = 256,\n",
    "    synapse_depth = 8,\n",
    "    memory_length = 25,\n",
    "    deep_nlms = True,\n",
    "    memory_hidden_dims = 16,\n",
    "    backbone_type = 'parity_backbone',\n",
    "    out_dims = parity_sequence_length * 2,\n",
    "    prediction_reshaper = [parity_sequence_length, 2],\n",
    "    dropout = 0.0,\n",
    "    do_layernorm_nlm = False,\n",
    "    positional_embedding_type = 'custom-rotational-1d'\n",
    ").to(device)\n",
    "\n",
    "# Initialize model parameters with dummy forward pass\n",
    "sample_batch = next(iter(trainloader))\n",
    "dummy_input = sample_batch[0][:1].to(device)\n",
    "with torch.no_grad():\n",
    "    _ = model(dummy_input)\n",
    "\n",
    "print(f'Model parameters: {sum(p.numel() for p in model.parameters()):,}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a89daf13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train Loss=0.007. Train Acc=0.997. Test Loss=0.015. Test Acc=0.994. LR=0.000100. Where_certain=43.95+-3.85 (33<->49).: 100%|██████████| 20000/20000 [1:55:52<00:00,  2.88it/s]  \n"
     ]
    }
   ],
   "source": [
    "model = train(model=model, trainloader=trainloader, testloader=testloader, device=device, training_iterations=20000, lr=1e-4, log_dir='./parity_logs')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca9cbd9b",
   "metadata": {},
   "source": [
    "Visualise a gif of a solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6ba0b9e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"show_videos\" style=\"border-spacing:0px;\"><tr><td style=\"padding:1px;\"><img width=\"400\" height=\"490\" style=\"image-rendering:auto; object-fit:cover;\" src=\"\"/></td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "reader = imageio.get_reader(\"parity_logs/prediction.gif\")\n",
    "frames = [reader.get_data(i) for i in range(min(len(reader), 100))]\n",
    "mediapy.show_video(frames, width=400, codec=\"gif\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "atm",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
